#include <brpc/server.h>
#include <butil/logging.h>
#include <regex>

#include "data/es.hpp"
#include "data/mysql_user.hpp"
#include "data/mysql.hpp"
#include "data/redis.hpp"
#include "channel.hpp"
#include "dms.hpp"
#include "etcd.hpp"
#include "utils.hpp"

#include "base.pb.h"
#include "user.pb.h"
#include "file.pb.h"

namespace im
{
    class UserServiceImpl : public UserService
    {
    public:
        UserServiceImpl(const DMSClient::ptr &dms_client,
            const std::shared_ptr<elasticlient::Client> &es_client,
            const std::shared_ptr<odb::core::database> &mysql_client,
            const std::shared_ptr<sw::redis::Redis> &redis_client,
            const ServiceManager::ptr &channel_manager,
            const std::string &file_service_name) :
            _mysql_user(std::make_shared<UserTable>(mysql_client)),
            _es_user(std::make_shared<ESUser>(es_client)),
            _redis_session(std::make_shared<Session>(redis_client)),
            _redis_status(std::make_shared<Status>(redis_client)),
            _redis_codes(std::make_shared<VerifyCode>(redis_client)),
            _dms_client(dms_client),
            _file_service_name(file_service_name),
            _mm_channels(channel_manager)
        {
            _es_user->createIndex();
        }

        bool check_name(const std::string& name){
            return name.size() < 22;
        }

        bool check_password(const std::string& pwd) {
            // 正则表达式：只能包含字母和数字，且长度在6到15之间
            std::regex pattern("^[a-zA-Z0-9]{6,15}$");
            return std::regex_match(pwd, pattern);
        }

        virtual void UserRegister(google::protobuf::RpcController *controller,
                                  const im::UserRegisterReq *request,
                                  im::UserRegisterRsp *response,
                                  google::protobuf::Closure *done){
            brpc::ClosureGuard rpc_guard(done);
            // 构建快捷响应
            auto err_resp = [this, response](const std::string &rid, const std::string &errmsg)->void{
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
            };

            // 1. 从请求中取出昵称和密码
            std::string nickname = request->nickname();
            std::string pwd = request->password();
            // 2. 检查昵称是否合法（只能包含字母，数字，连字符-，下划线_，长度限制 3~21 之间）
            bool ret = check_name(nickname);
            if(ret == false)
            {
                LOG_CRITICAL("{} - 用户名长度不合法！ - {}", request->request_id(), nickname);
                return err_resp(request->request_id(), "用户名长度不合法!");
            }
            // 3. 检查密码是否合法（只能包含字母，数字，长度限制 6~15 之间）
            ret = check_password(pwd);
            if(ret == false)
            {
                LOG_CRITICAL("{} - 密码只能包含数字和字母！- {}", request->request_id(), pwd);
                return err_resp(request->request_id(), "密码长度为6~15为，只能包含数字和字母!");
            }
            // 4. 根据昵称在数据库进行判断是否昵称已存在
            auto user_ptr = _mysql_user->select_by_nickname(nickname);
            if(nullptr != user_ptr){
                LOG_CRITICAL("{} -用户名被占用- {}", request->request_id(), nickname);
                return err_resp(request->request_id(), "用户名被占用!");
            }
            // 5. 向数据库新增数据
            std::string uid = uuid();
            User user(uid, nickname, pwd);
            ret = _mysql_user->insert(user);
            if(ret == false){
                LOG_CRITICAL("{} - Mysql数据库新增数据失败！", request->request_id());
                return err_resp(request->request_id(), "Mysql数据库新增数据失败!");
            }
            // 6. 向 ES 服务器中新增用户信息
            ret = _es_user->appendData(uid, "", nickname, "", "");
            if(ret == false){
                LOG_CRITICAL("{} - ES搜索引擎新增数据失败！", request->request_id());
                return err_resp(request->request_id(), "ES搜索引擎新增数据失败！");
            }
            // 7. 组织响应，进行成功与否的响应即可
            response->set_request_id(request->request_id());
            response->set_success(true);
        }
        virtual void UserLogin(google::protobuf::RpcController *controller,
                               const im::UserLoginReq *request,
                               im::UserLoginRsp *response,
                               google::protobuf::Closure *done){
            LOG_INFO("收到 用户名登入 请求！");
            brpc::ClosureGuard rpc_guard(done);
            // 构建快捷响应
            auto err_resp = [this, response](const std::string &rid, const std::string &errmsg)->void{
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
            };

            // 1. 从请求中取出昵称和密码
            std::string nickname = request->nickname();
            std::string pwd = request->password();  
            // 2. 通过昵称获取用户信息，进行密码是否一致的判断
            auto ptr_user = _mysql_user->select_by_nickname(nickname);
            if(ptr_user == nullptr || ptr_user->password() != pwd || ptr_user->user_name() != nickname)
            {
                LOG_CRITICAL("{} - 用户名或密码错误 - {}-{}！", request->request_id(), nickname, pwd);
                return err_resp(request->request_id(), "用户名或密码错误!");
            }
            // 3. 根据 redis 中的登录标记信息是否存在判断用户是否已经登录。
            bool ret = _redis_status->exists(ptr_user->user_id());
            if(ret == true){
                LOG_CRITICAL("{} - 用户已在其他地方登录 - {}！", request->request_id(), nickname);
                return err_resp(request->request_id(), "用户已在其他地方登录!");
            }
            // 4. 构造会话 ID，生成会话键值对，向 redis 中添加会话信息以及登录标记信息
            std::string ssid = uuid();
            ret = _redis_session->append(ssid, ptr_user->user_id());
            ret &= _redis_status->append(ptr_user->user_id());
            if(ret == false){
                LOG_CRITICAL("{} - redis缓存登入状态失败 - {}！", request->request_id(), nickname);
                return err_resp(request->request_id(), "redis缓存登入状态失败!");
            }
            // 5. 组织响应，返回生成的会话 ID
            response->set_request_id(request->request_id());
            response->set_success(true);
            response->set_login_session_id(ssid);
        }
        
        bool check_phone(const std::string& phone) {
            // 正则表达式：1位：1，2位：数字3~9，3~11位：任意数字
            std::regex pattern("^1[3-9]\\d{9}$");
            return std::regex_match(phone, pattern);
        }

        virtual void GetPhoneVerifyCode(google::protobuf::RpcController *controller,
                                        const im::PhoneVerifyCodeReq *request,
                                        im::PhoneVerifyCodeRsp *response,
                                        google::protobuf::Closure *done){
            LOG_INFO("收到 获取手机好验证码 请求！");
            brpc::ClosureGuard rpc_guard(done);
            // 构建快捷响应
            auto err_resp = [this, response](const std::string &rid, const std::string &errmsg)->void{
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
            };
            // 1. 从请求中取出手机号码
            std::string phone = request->phone_number();
            // 2. 验证手机号码格式是否正确（必须以 1 开始，第二位 3~9 之间，后边 9 个数字字符）
            bool ret = check_phone(phone);
            if (ret == false) {
                LOG_CRITICAL("{} - 手机号码格式错误 - {}！", request->request_id(), phone);
                return err_resp(request->request_id(), "手机号码格式错误!");
            }
            // 3. 生成 4 位随机验证码
            std::string code_id = uuid();
            // std::string code = verify_code();
            std::string code = "1234";
            // 阿里云的短信服务还要备案，我这里没有备案，所以收不到短信，先不进行验证，硬编码验证码
            // // 4. 基于短信平台 SDK 发送验证码
            // ret = _dms_client->send_verify_code(phone, code);
            // if (ret == false){
            //     LOG_CRITICAL("{} - 短信验证码发送失败 - {}！", request->request_id(), phone);
            //     return err_resp(request->request_id(), "短信验证码发送失败!");
            // }
            // 5. 构造验证码 ID，添加到 redis 验证码映射键值索引中
            ret = _redis_codes->append(code_id, code);
            if(ret == false){
                LOG_CRITICAL("{} - redis缓存验证码失败 - {}！", request->request_id(), phone);
                return err_resp(request->request_id(), "redis缓存验证码失败!");
            }
            // 6. 组织响应，返回生成的验证码 ID
            response->set_request_id(request->request_id());
            response->set_success(true);
            response->set_verify_code_id(code_id);
            LOG_DEBUG("获取短信验证码处理完成！");
        }

        virtual void PhoneRegister(google::protobuf::RpcController *controller,
                                   const im::PhoneRegisterReq *request,
                                   im::PhoneRegisterRsp *response,
                                   google::protobuf::Closure *done){
            LOG_INFO("收到 手机号注册 请求！");
            brpc::ClosureGuard rpc_guard(done);
            auto err_resp = [this, response](const std::string &rid, 
                const std::string &errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };
            // 1. 从请求中取出手机号码和验证码
            std::string phone = request->phone_number();
            std::string code_id = request->verify_code_id();
            std::string code = request->verify_code();
            // 2. 检查注册手机号码是否合法
            bool ret = check_phone(phone);
            if (ret == false) {
                LOG_CRITICAL("{} - 手机号码格式错误 - {}！", request->request_id(), phone);
                return err_resp(request->request_id(), "手机号码格式错误!");
            }
            // 3. 从 redis 数据库中进行验证码 ID-验证码一致性匹配
            auto r_code = _redis_codes->code(code_id);
            if(r_code && *r_code != code){
                LOG_CRITICAL("{} - 验证码错误 - {}-{}！", request->request_id(), code_id, code);
                return err_resp(request->request_id(), "验证码错误!");
            
            }
            // 4. 通过数据库查询判断手机号是否已经注册过
            auto user_ptr = _mysql_user->select_by_phone(phone);
            if(user_ptr){
                LOG_CRITICAL("{} - 该手机号已注册过用户 - {}！", request->request_id(), phone);
                return err_resp(request->request_id(), "该手机号已注册过用户!");
            }
            // 5. 向数据库新增用户信息
            std::string uid = uuid();
            User user(uid, phone);
            ret = _mysql_user->insert(user);
            if (ret == false) {
                LOG_CRITICAL("{} - 向数据库添加用户信息失败 - {}！", request->request_id(), phone);
                return err_resp(request->request_id(), "向数据库添加用户信息失败!");
            }
            // 6. 向 ES 服务器中新增用户信息
            ret = _es_user->appendData(uid, phone, "", "", "");
            if (ret == false) {
                LOG_CRITICAL("{} - ES搜索引擎新增数据失败！", request->request_id());
                return err_resp(request->request_id(), "ES搜索引擎新增数据失败！");
            }
            // 7. 组织响应，返回注册成功与否
            response->set_request_id(request->request_id());
            response->set_success(true);
        }

        virtual void PhoneLogin(::google::protobuf::RpcController *controller,
                                const ::im::PhoneLoginReq *request,
                                ::im::PhoneLoginRsp *response,
                                ::google::protobuf::Closure *done){
            LOG_INFO("收到 手机号登入 请求！");
            brpc::ClosureGuard rpc_guard(done);
            auto err_resp = [this, response](const std::string &rid, 
                const std::string &errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
            };
            // 1. 从请求中取出手机号码和验证码 ID，以及验证码。
            std::string phone = request->phone_number();
            std::string code_id = request->verify_code_id();
            std::string code = request->verify_code();
            // 2. 检查注册手机号码是否合法
            bool ret = check_phone(phone);
            if (ret == false) {
                LOG_CRITICAL("{} - 手机号码格式错误 - {}！", request->request_id(), phone);
                return err_resp(request->request_id(), "手机号码格式错误!");
            }
            // 3. 根据手机号从数据数据进行用户信息查询，判断用用户是否存在
            auto user_ptr = _mysql_user->select_by_phone(phone);
            if(!user_ptr){
                LOG_CRITICAL("{} - 该手机号未注册用户 - {}！", request->request_id(), phone);
                return err_resp(request->request_id(), "该手机号未注册过用户!");
            }
            // 4. 从 redis 数据库中进行验证码 ID-验证码一致性匹配
            auto r_code = _redis_codes->code(code_id);
            if(r_code && *r_code != code){
                LOG_CRITICAL("{} - 验证码错误 - {}-{}！", request->request_id(), code_id, code);
                return err_resp(request->request_id(), "验证码错误!");
            }
            // 5. 根据 redis 中的登录标记信息是否存在判断用户是否已经登录。
            ret = _redis_status->exists(user_ptr->user_id());
            if (ret == true) {
                LOG_CRITICAL("{} - 用户已在其他地方登录 - {}！", request->request_id(), phone);
                return err_resp(request->request_id(), "用户已在其他地方登录!");
            }
            // 6. 构造会话 ID，生成会话键值对，向 redis 中添加会话信息，登录标记信息，删除验证过的验证码
            std::string ssid = uuid();
            _redis_session->append(ssid, user_ptr->user_id());
            _redis_status->append(user_ptr->user_id());
            _redis_codes->remove(code_id);
            // 7. 组织响应，返回生成的会话 ID
            response->set_request_id(request->request_id());
            response->set_success(true);
            response->set_login_session_id(ssid);
        }
// -------------------------  用户登录之后才会进行的操作 -------------------------
        virtual void GetUserInfo(google::protobuf::RpcController *controller,
                                 const im::GetUserInfoReq *request,
                                 im::GetUserInfoRsp *response,
                                 google::protobuf::Closure *done){
            LOG_INFO("收到来自 {} 的 获取用户信息 请求！", request->request_id());
            brpc::ClosureGuard rpc_guard(done);
            auto err_resp = [this, response](const std::string &rid, 
                const std::string &errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
            };
            // 1. 从请求中取出用户 ID
            std::string uid = request->user_id();
            // 2. 通过用户 ID，从数据库中查询用户信息
            auto user_ptr = _mysql_user->select_by_id(uid);
            if(user_ptr == nullptr){
                LOG_CRITICAL("{} - 未找到用户信息 - {}！", request->request_id(), uid);
                return err_resp(request->request_id(), "未找到用户信息!");
            }
            // 3. 根据用户信息中的头像 ID，从文件服务器获取头像文件数据，组织完整用户信息
            UserInfo *user_info = response->mutable_user_info();
            user_info->set_user_id(user_ptr->user_id());
            user_info->set_nickname(user_ptr->user_name());
            user_info->set_description(user_ptr->description());
            user_info->set_phone(user_ptr->phone());
            
            if(!user_ptr->avatar_id().empty()){
                //从信道管理对象中，获取到连接了文件管理子服务的channel
                auto channel = _mm_channels->choose(_file_service_name);
                if(channel == nullptr){
                    LOG_CRITICAL("{} - 未找到文件管理子服务节点 - {} - {}！", request->request_id(), _file_service_name, uid);
                    return err_resp(request->request_id(), "未找到文件管理子服务节点!");
                }
                //作为客户端，发起文件子服务的rpc请求，进行头像文件下载
                FileService_Stub stub(channel.get()); 
                GetSingleFileReq req;
                GetSingleFileRsp rsp;
                req.set_request_id(request->request_id());
                req.set_file_id(user_ptr->avatar_id());

                brpc::Controller cntl;
                stub.GetSingleFile(&cntl, &req, &rsp, nullptr);
                if(cntl.Failed() == true || rsp.success() == false){
                    LOG_CRITICAL("{} - 文件子服务调用失败：{}！", request->request_id(), cntl.ErrorText());
                    return err_resp(request->request_id(), "文件子服务调用失败!");
                }
                user_info->set_avatar(rsp.file_data().file_content());
            }
            // 4. 组织响应，返回用户信息
            response->set_request_id(request->request_id());
            response->set_success(true);
        }
        virtual void GetMultiUserInfo(google::protobuf::RpcController *controller,
                                      const ::im::GetMultiUserInfoReq *request,
                                      im::GetMultiUserInfoRsp *response,
                                      google::protobuf::Closure *done){
            brpc::ClosureGuard rpc_guard(done);
            LOG_INFO("收到来自 {} 的 获取批量用户信息 请求！", request->request_id());
            auto err_resp = [this, response](const std::string &rid, 
                const std::string &errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
            };
            // 1. 从请求中取出 用户们的ID
            std::vector<std::string> uid_list;
            for(auto uid : request->users_id()){
                uid_list.push_back(uid);
            }
            // 2. 通过用户 ID，从数据库中查询用户信息
            auto users = _mysql_user->select_multi_users(uid_list);
            if(users.size() != request->users_id_size()){
                LOG_CRITICAL("{} - 从数据库查找的用户信息数量不一致 - {}-{}！", 
                            request->request_id(), request->users_id_size(), users.size());
                return err_resp(request->request_id(), "从数据库查找的用户信息数量不一致!");
            }
            // 3. 根据用户信息中的头像 ID，从文件服务器获取头像文件数据，组织完整用户信息
            //作为客户端，发起文件子服务的rpc请求，进行头像文件下载
            auto channel = _mm_channels->choose(_file_service_name);
            if(channel == nullptr){
                LOG_CRITICAL("{} - 未找到文件管理子服务节点 - {}！", request->request_id(), _file_service_name);
                return err_resp(request->request_id(), "未找到文件管理子服务节点!");
            }
            FileService_Stub stub(channel.get());
            GetMultiFileReq req;
            req.set_request_id(request->request_id());
            for (auto &user : users) {
                if(!user.avatar_id().empty())
                    req.add_file_id_list(user.avatar_id());
            }
            GetMultiFileRsp rsp;
            brpc::Controller cntl;
            stub.GetMultiFile(&cntl, &req, &rsp, nullptr);
            if (cntl.Failed() == true || rsp.success() == false) {
                LOG_CRITICAL("{} - 文件子服务调用失败：{} - {}！", request->request_id(), 
                    _file_service_name, cntl.ErrorText());
                return err_resp(request->request_id(), "文件子服务调用失败!");
            }
            // 组织响应
            auto* users_map = response->mutable_users_info();
            auto* files_map = rsp.mutable_file_data();
            for(auto user : users){
                UserInfo user_info;
                user_info.set_user_id(user.user_id());
                user_info.set_nickname(user.user_name());
                user_info.set_phone(user.phone());
                user_info.set_description(user.description());
                user_info.set_avatar((*files_map)[user.avatar_id()].file_content());
                (*users_map)[user.user_id()] = user_info;
            }
            response->set_request_id(request->request_id());
            response->set_success(true);
        }
        virtual void SetUserAvatar(google::protobuf::RpcController *controller,
                                   const ::im::SetUserAvatarReq *request,
                                   im::SetUserAvatarRsp *response,
                                   google::protobuf::Closure *done){
            LOG_INFO("收到来自 {} 的 设置用户头像 请求！", request->request_id());
            brpc::ClosureGuard rpc_guard(done);
            auto err_resp = [this, response](const std::string& rid, const std::string& err_msg){
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(err_msg);
            };
            // 1. 从请求中取出用户 ID 与头像数据
            std::string uid = request->user_id();
            std::string avatar_data = request->avatar();
            // 2. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
            auto user_ptr = _mysql_user->select_by_id(uid);
            if(user_ptr == nullptr){
                LOG_CRITICAL("{} - 未找到用户信息 - {}！", request->request_id(), uid);
                return err_resp(request->request_id(), "未找到用户信息!");
            }
            // 3. 上传头像文件到文件子服务，
            auto channel =  _mm_channels->choose(_file_service_name);
            if(channel == nullptr){
                LOG_CRITICAL("{} - 未找到文件管理子服务节点 - {}！", request->request_id(), _file_service_name);
                return err_resp(request->request_id(), "未找到文件管理子服务节点!");
            }
            FileService_Stub stub(channel.get());
            PutSingleFileReq req;
            PutSingleFileRsp rsp;
            req.set_request_id(request->request_id());
            req.mutable_file_data()->set_file_name("");
            req.mutable_file_data()->set_file_size(request->avatar().size());
            req.mutable_file_data()->set_file_content(request->avatar());
            brpc::Controller cntl;
            stub.PutSingleFile(&cntl, &req, &rsp, nullptr);
            if(cntl.Failed() == true || rsp.success() == false){
                LOG_CRITICAL("{} - 文件子服务调用失败：{}！", request->request_id(), cntl.ErrorText());
                return err_resp(request->request_id(), "文件子服务调用失败!");
            }
            // 4. 将返回的头像文件 ID 更新到数据库中
            std::string avatar_id = rsp.file_info().file_id();
            user_ptr->avatar_id(avatar_id);
            bool ret = _mysql_user->update(*user_ptr);
            if(ret == false){
                LOG_CRITICAL("{} - 更新数据库用户头像ID失败 ：{}！", request->request_id(), avatar_id);
                return err_resp(request->request_id(), "更新数据库用户头像ID失败!");
            }
            // 5. 更新 ES 服务器中用户信息
            _es_user->appendData(user_ptr->user_id(), user_ptr->phone(), user_ptr->user_name(),
                                user_ptr->description(), user_ptr->avatar_id());
            LOG_DEBUG("SetUserAvatar - 内部生成的头像ID：{}", user_ptr->avatar_id());
            // 6. 组织响应，返回更新成功与否
            response->set_request_id(request->request_id());
            response->set_success(true);
            response->set_errmsg("");
        }
        virtual void SetUserNickname(google::protobuf::RpcController *controller,
                                     const ::im::SetUserNicknameReq *request,
                                     im::SetUserNicknameRsp *response,
                                     google::protobuf::Closure *done){
            LOG_INFO("收到来自 {} 的 设置用户昵称 请求！", request->request_id());
            brpc::ClosureGuard rpc_guard(done);
            auto err_resp = [this, response](const std::string& rid, const std::string& err_msg){
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(err_msg);
            };
            // 1. 从请求中取出用户 ID 与新的昵称
            std::string uid = request->user_id();
            std::string new_name = request->nickname();
            // 2. 判断昵称格式是否正确
            bool ret = check_name(new_name);
            if(ret == false){
                LOG_CRITICAL("{} - 用户名长度不合法！", request->request_id());
                return err_resp(request->request_id(), "用户名长度不合法!");
            }
            // 3. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
            auto user_ptr = _mysql_user->select_by_id(request->user_id());
            if(user_ptr == nullptr){
                LOG_CRITICAL("{} - 未找到用户信息 - {}！", request->request_id(), uid);
                return err_resp(request->request_id(), "未找到用户信息!");
            }
            // 4. 将新的昵称更新到数据库中
            user_ptr->user_name(new_name);
            ret = _mysql_user->update(*user_ptr);
            if(ret == false){
                LOG_CRITICAL("{} - 更新数据库用户昵称失败 ：{}！", request->request_id(), new_name);
                return err_resp(request->request_id(), "更新数据库用户昵称失败!");
            }
            // 5. 更新 ES 服务器中用户信息
            _es_user->appendData(user_ptr->user_id(), user_ptr->phone(), user_ptr->user_name(),
                                user_ptr->description(), user_ptr->avatar_id());
            // 6. 组织响应，返回更新成功与否
            response->set_request_id(request->request_id());
            response->set_success(true);
            response->set_errmsg("");
        }
        virtual void SetUserDescription(google::protobuf::RpcController *controller,
                                        const im::SetUserDescriptionReq *request,
                                        im::SetUserDescriptionRsp *response,
                                        google::protobuf::Closure *done){
            LOG_INFO("收到来自 {} 的 设置用户签名 请求！", request->request_id());
            brpc::ClosureGuard rpc_guard(done);
            auto err_resp = [this, response](const std::string& rid, const std::string& err_msg){
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(err_msg);
            };
            // 1. 从请求中取出用户 ID 与新的签名
            std::string uid = request->user_id();
            std::string new_description = request->description();
            // 2. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
            auto user_ptr = _mysql_user->select_by_id(request->user_id());
            if(user_ptr == nullptr){
                LOG_CRITICAL("{} - 未找到用户信息 - {}！", request->request_id(), uid);
                return err_resp(request->request_id(), "未找到用户信息!");
            }
            // 3. 将新的签名更新到数据库中
            user_ptr->description(new_description);
            bool ret = _mysql_user->update(*user_ptr);
            if(ret == false){
                LOG_CRITICAL("{} - 更新数据库用户签名失败 ：{}！", request->request_id(), new_description);
                return err_resp(request->request_id(), "更新数据库用户签名失败!");
            }
            // 4. 更新 ES 服务器中用户信息
            _es_user->appendData(user_ptr->user_id(), user_ptr->phone(), user_ptr->user_name(),
                                user_ptr->description(), user_ptr->avatar_id());
            // 5. 组织响应，返回更新成功与否
            response->set_request_id(request->request_id());
            response->set_success(true);
            response->set_errmsg("");
        }
        virtual void SetUserPhoneNumber(google::protobuf::RpcController *controller,
                                        const im::SetUserPhoneNumberReq *request,
                                        im::SetUserPhoneNumberRsp *response,
                                        google::protobuf::Closure *done){
            LOG_INFO("收到来自 {} 的 设置用户手机号 请求！", request->request_id());
            brpc::ClosureGuard rpc_guard(done);
            auto err_resp = [this, response](const std::string& rid, const std::string& err_msg){
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(err_msg);
            };
            // 1. 从请求中取出手机号码和验证码 ID，以及验证码。
            std::string uid = request->user_id();
            std::string new_phone = request->phone_number();
            std::string code_id = request->phone_verify_code_id();
            std::string code = request->phone_verify_code();
            // 2. 检查注册手机号码是否合法
            bool ret = check_phone(new_phone);
            if (ret == false) {
                LOG_CRITICAL("{} - 手机号码格式错误 - {}！", request->request_id(), new_phone);
                return err_resp(request->request_id(), "手机号码格式错误!");
            }
            // 3. 从 redis 数据库中进行验证码 ID-验证码一致性匹配
            auto r_code = _redis_codes->code(code_id);
            if(r_code != code){
                LOG_CRITICAL("{} - 验证码错误 - {}-{}！", request->request_id(), code_id, code);
                return err_resp(request->request_id(), "验证码错误!");
            
            }
            // 4. 根据手机号从数据数据进行用户信息查询，判断用户是否存在
            auto user_ptr = _mysql_user->select_by_id(uid);
            if(user_ptr == nullptr){
                LOG_CRITICAL("{} - 未找到用户信息 - {}！", request->request_id(), uid);
                return err_resp(request->request_id(), "未找到用户信息!");
            }
            // 5. 将新的手机号更新到数据库中
            user_ptr->phone(new_phone);
            ret = _mysql_user->update(*user_ptr);
            if(ret == false){
                LOG_CRITICAL("{} - 更新数据库用户手机号失败 ：{}！", request->request_id(), new_phone);
                return err_resp(request->request_id(), "更新数据库用户手机号失败!");
            }
            // 6. 更新 ES 服务器中用户信息
            _es_user->appendData(user_ptr->user_id(), user_ptr->phone(), user_ptr->user_name(),
                                user_ptr->description(), user_ptr->avatar_id());
            // 7. 组织响应，返回更新成功与否
            response->set_request_id(request->request_id());
            response->set_success(true);
            response->set_errmsg("");
        }

    private:
        UserTable::ptr _mysql_user;
        ESUser::ptr _es_user;
        Session::ptr _redis_session;
        Status::ptr _redis_status;
        VerifyCode::ptr _redis_codes;
        DMSClient::ptr _dms_client;

        std::string _file_service_name;
        ServiceManager::ptr _mm_channels;
    };

    class UserServer{
    public:
        using ptr = std::shared_ptr<UserServer>;
        UserServer(const Discover::ptr service_discoverer, 
            const Registry::ptr &reg_client,
            const std::shared_ptr<elasticlient::Client> &es_client,
            const std::shared_ptr<odb::core::database> &mysql_client,
            std::shared_ptr<sw::redis::Redis> &redis_client,
            const std::shared_ptr<brpc::Server> &server):
            _service_discoverer(service_discoverer),
            _registry_client(reg_client),
            _es_client(es_client),
            _mysql_client(mysql_client),
            _redis_client(redis_client),
            _rpc_server(server){}
        void start(){
            _rpc_server->RunUntilAskedToQuit();
        }

    private:
        Discover::ptr _service_discoverer;
        Registry::ptr _registry_client;

        std::shared_ptr<elasticlient::Client> _es_client;
        std::shared_ptr<odb::core::database> _mysql_client;
        std::shared_ptr<sw::redis::Redis> _redis_client;
        std::shared_ptr<brpc::Server> _rpc_server;
    };

    class UserServerBuild{
    public:
        UserServerBuild(){}

        void init_dms_client(const std::string &access_key_id, const std::string &access_key_secret){
            _dms_client = std::make_shared<DMSClient>(access_key_id, access_key_secret);
        }

        void init_ES_client(const std::vector<std::string> host_list){
            _es_client = ESClientFactory::create(host_list);
        }
        void init_MySql_client(
            const std::string &user, const std::string &pwd,
            const std::string &host, const std::string &db,
            const std::string &cset, int port, int conn_pool_count){
            _mysql_client = ODBFactory::create(user, pwd, host, db, cset, port, conn_pool_count);
        }
        void init_Redis_client(const std::string &host, int port, int db_num, bool keep_alive){
            _redis_client = RedisClientFactory::create(host, port, db_num, keep_alive);
        }

        void init_discovery_client(const std::string &reg_host,
            const std::string &base_service_name,
            const std::string &file_service_name) {
            _file_service_name = file_service_name;
            _mm_channels = std::make_shared<ServiceManager>();
            _mm_channels->declared(file_service_name);
            LOG_DEBUG("设置文件子服务为需添加管理的子服务：{}", file_service_name);
            auto put_cb = std::bind(&ServiceManager::onServiceOnline, _mm_channels.get(), std::placeholders::_1, std::placeholders::_2);
            auto del_cb = std::bind(&ServiceManager::onServiceOffline, _mm_channels.get(), std::placeholders::_1, std::placeholders::_2);
            _service_discoverer = std::make_shared<Discover>(reg_host, base_service_name, put_cb, del_cb);
        }

        void init_register_client(const std::string& reg_host, const std::string& service_name, const std::string& access_host){
            _registry_client = std::make_shared<Registry>(reg_host);        // 登入IP
            _registry_client->register_server(service_name, access_host);   // 注册服务
        }

        void init_rpc_server(uint port, int timeout, int num_threads){
            if (!_es_client) {
                LOG_CRITICAL("还未初始化“ES搜索”模块！");
                abort();
            }
            if (!_mysql_client) {
                LOG_CRITICAL("还未初始化“mysql客户端”模块! ");
                abort();
            }
            if (!_redis_client) {
                LOG_CRITICAL("还未初始化“redis缓存”模块！");
                abort();
            }
            if (!_mm_channels) {
                LOG_CRITICAL("还未初始化“信道管理”模块！");
                abort();
            }

            _rpc_server = std::make_shared<brpc::Server>();
            UserServiceImpl *user_service = new UserServiceImpl(_dms_client, _es_client, _mysql_client,
                                                _redis_client, _mm_channels, _file_service_name);
            _rpc_server->AddService(user_service, brpc::ServiceOwnership::SERVER_OWNS_SERVICE);
            
            brpc::ServerOptions opt;
            opt.idle_timeout_sec = timeout;
            opt.num_threads = num_threads;
            if(_rpc_server->Start(port, &opt) != 0 ){
                LOG_CRITICAL("启动服务器失败！");
                abort();
            }
        }


        UserServer::ptr Build(){
            if (!_service_discoverer) {
                LOG_CRITICAL("还未初始化“服务发现”模块! ");
                abort();
            }
            if (!_registry_client) {
                LOG_CRITICAL("还未初始化“服务注册”模块！");
                abort();
            }
            if (!_rpc_server) {
                LOG_CRITICAL("还未初始化“RPC服务器”模块! ");
                abort();
            }
            return std::make_shared<UserServer>(
                _service_discoverer, _registry_client,
                _es_client, _mysql_client, _redis_client, _rpc_server);
        }

    private:
        std::shared_ptr<DMSClient> _dms_client;
        std::shared_ptr<elasticlient::Client> _es_client;
        std::shared_ptr<odb::core::database> _mysql_client;
        std::shared_ptr<sw::redis::Redis> _redis_client;

        std::string _file_service_name;
        ServiceManager::ptr _mm_channels;

        Discover::ptr _service_discoverer;
        Registry::ptr _registry_client;
        std::shared_ptr<brpc::Server> _rpc_server;
    };
} // end im